Complete Linux/Complete Linux.iso/docs/apps/database/ingres04.lzh/source/ctlmod/readinput.c

C/C++ Source or Header | 1985-01-23 | 4.0 KB | 204 lines

# include    "ctlmod.h"
# include    "pipes.h"
# include    <resp.h>
# include    <ingres.h>
# include    <aux.h>
# include    <tree.h>
# include    <sccs.h>

SCCSID(@(#)readinput.c    8.1    12/31/84)

/*
**  READINPUT -- read the input pipe and determine next function
**
**    The input pipe is read (using pb_get).  Parameters are
**    collected and set up in the global Ctx.ctx_pv.  *ppb
**    is set to the new function, block type, etc.
**
**    If an error block is read, the error routine processing
**    is invoked.
**
**    Parameters:
**        ppb -- a pointer to the pipe block to read into;
**            also becomes part of the return value.
**
**    Returns:
**        nothing directly.
**
**    Side Effects:
**        Sets Ctx.ctx_pv, Ctx.ctx_pc to the new parmv &
**            parmc read from the pipe.
**        Sets the *ppb struct to indicate state, etc.
**
**    Trace Flags:
**        10.0 - 10.5
*/

readinput(ppb)
register pb_t    *ppb;
{
    register int    i;

    /*
    **  Top Loop.
    **    Executed once for each complete block read.  Normally
    **    only executed once, but can be more if an error
    **    block is read.
    **
    **    We mark Qbuf first, so we can free any parameters
    **    when they are no longer needed (such as when they
    **    are passed to another process).
    */

    Ctx.ctx_pmark = markbuf(Qbuf);
# ifdef xCTR1
    if (tTf(10, 0))
        lprintf("readinput: mark %d, errfn %x, ppb %x\n", Ctx.ctx_pmark, Ctx.ctx_errfn, ppb);
# endif

    for (;;)
    {
        /* prime the input (reads first block) */
        pb_prime(ppb, PB_NOTYPE);
# ifdef xCTR2
        if (tTf(10, 1))
            lprintf("readinput: type %d\n", ppb->pb_type);
# endif

        /* if this is a response block, return immediately */
        if (ppb->pb_type == PB_RESP)
        {
            i = pb_get(ppb, (char *) &Resp, sizeof Resp);
            if (i != sizeof Resp)
                syserr("readinput: Resp sz %d", i);
/*
            read_arg(ppb, &Resp.resp_rval);
*/
            break;
        }

        /*
        **  Parameter Loop.
        **    Wander through and start reading parameters.
        */

        for (Ctx.ctx_pc = 0; Ctx.ctx_pc < PV_MAXPC; Ctx.ctx_pc++)
        {
            if (read_arg(ppb, &Ctx.ctx_pv[Ctx.ctx_pc]) == PV_EOF)
                break;
        }

        /* out of loop, check for vector overflow */
        if (Ctx.ctx_pc >= PV_MAXPC)
            syserr("readinput: overflow");

        /* check for error blocks */
        if (ppb->pb_type == PB_ERR)
        {
            proc_err(ppb, Ctx.ctx_pc, Ctx.ctx_pv);
            syserr("readinput: proc_err");
        }


        /* non-error block */
# ifdef xCM_DEBUG
        if (ppb->pb_type != PB_REG)
            syserr("readinput: pb_type %d", ppb->pb_type);
# endif
        Ctx.ctx_resp = ppb->pb_resp;
        break;
    }
# ifdef xCTR1
    if (tTf(10, 4))
    {
        lprintf("readinput: ");
        pb_dump(ppb, FALSE);
    }
# endif
}
/*
**  READ_ARG -- Read a single argument from pipe
**
**    An argument can be as simple as an integer, or as complex
**    as a query tree.
**
**    Parameters:
**        ppb -- the pipe block to read from.
**        pparm -- the parameter descripter to put the
**            argument in.
**
**    Returns:
**        none.
**
**    Side Effects:
**        May allocate space from Qbuf for trees, etc.
**
**    Called By:
**        readinput
**
**    Trace Flags:
**        10.6 - 10.7
*/

read_arg(ppb, pparm)
register pb_t    *ppb;
register PARM    *pparm;
{
    auto char    ptype;
    auto short    plen;
    register int    i;
    register char    *p;
    QTREE        *q;
    extern char    *need();
    extern QTREE    *readqry();

    /* get the parameter type */
    i = pb_get(ppb, &ptype, 1);
    if (i == 0)
    {
        pparm->pv_type = PV_EOF;
        pparm->pv_val.pv_str = NULL;
        return (PV_EOF);
    }
    i = pb_get(ppb, (char *) &plen, 2);
    if (i < 2)
        syserr("readarg: pb_get %d", i);

    /* figure out the type */
    switch (ptype)
    {
      case PV_INT:
# ifdef xCM_DEBUG
        if (plen != sizeof pparm->pv_val.pv_int)
            syserr("readinput: PV_INT %d", plen);
# endif
        pb_get(ppb, (char *) &pparm->pv_val.pv_int, plen);
        break;

      case PV_STR:
      case PV_TUPLE:
        p = need(Qbuf, plen);
        pb_get(ppb, p, plen);
        pparm->pv_val.pv_str = p;
        break;

      case PV_QTREE:
        q = readqry(pb_get, (int) ppb, TRUE);
        pparm->pv_val.pv_qtree = q;
        break;

      case PV_EOF:
        /* this case is allowed for the mon-par interface */
        break;

      default:
        syserr("readinput: type %d len %d", ptype, plen);
    }

    /* save the type & length */
    pparm->pv_type = ptype;
    pparm->pv_len = plen;

    return (ptype);
}